home *** CD-ROM | disk | FTP | other *** search
# Source Generated with Decompyle++ # File: in.pyc (Python 2.5) '''program/module to trace Python program or function execution Sample use, command line: trace.py -c -f counts --ignore-dir \'$prefix\' spam.py eggs trace.py -t --ignore-dir \'$prefix\' spam.py eggs trace.py --trackcalls spam.py eggs Sample use, programmatically import sys # create a Trace object, telling it what to ignore, and whether to # do tracing or line-counting or both. tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix,], trace=0, count=1) # run the new command using the given tracer tracer.run(\'main()\') # make a report, placing output in /tmp r = tracer.results() r.write_results(show_missing=True, coverdir="/tmp") ''' import linecache import os import re import sys import threading import token import tokenize import types import gc try: import cPickle pickle = cPickle except ImportError: import pickle def usage(outfile): outfile.write("Usage: %s [OPTIONS] <file> [ARGS]\n\nMeta-options:\n--help Display this help then exit.\n--version Output version information then exit.\n\nOtherwise, exactly one of the following three options must be given:\n-t, --trace Print each line to sys.stdout before it is executed.\n-c, --count Count the number of times each line is executed\n and write the counts to <module>.cover for each\n module executed, in the module's directory.\n See also `--coverdir', `--file', `--no-report' below.\n-l, --listfuncs Keep track of which functions are executed at least\n once and write the results to sys.stdout after the\n program exits.\n-T, --trackcalls Keep track of caller/called pairs and write the\n results to sys.stdout after the program exits.\n-r, --report Generate a report from a counts file; do not execute\n any code. `--file' must specify the results file to\n read, which must have been created in a previous run\n with `--count --file=FILE'.\n\nModifiers:\n-f, --file=<file> File to accumulate counts over several runs.\n-R, --no-report Do not generate the coverage report files.\n Useful if you want to accumulate over several runs.\n-C, --coverdir=<dir> Directory where the report files. The coverage\n report for <package>.<module> is written to file\n <dir>/<package>/<module>.cover.\n-m, --missing Annotate executable lines that were not executed\n with '>>>>>> '.\n-s, --summary Write a brief summary on stdout for each file.\n (Can only be used with --count or --report.)\n\nFilters, may be repeated multiple times:\n--ignore-module=<mod> Ignore the given module and its submodules\n (if it is a package).\n--ignore-dir=<dir> Ignore files in the given directory (multiple\n directories can be joined by os.pathsep).\n" % sys.argv[0]) PRAGMA_NOCOVER = '#pragma NO COVER' rx_blank = re.compile('^\\s*(#.*)?$') class Ignore: def __init__(self, modules = None, dirs = None): if not modules: pass self._mods = [] if not dirs: pass self._dirs = [] self._dirs = map(os.path.normpath, self._dirs) self._ignore = { '<string>': 1 } def names(self, filename, modulename): if self._ignore.has_key(modulename): return self._ignore[modulename] for mod in self._mods: if mod == modulename: self._ignore[modulename] = 1 return 1 n = len(mod) if mod == modulename[:n] and modulename[n] == '.': self._ignore[modulename] = 1 return 1 continue if filename is None: self._ignore[modulename] = 1 return 1 for d in self._dirs: if filename.startswith(d + os.sep): self._ignore[modulename] = 1 return 1 continue self._ignore[modulename] = 0 return 0 def modname(path): '''Return a plausible module name for the patch.''' base = os.path.basename(path) (filename, ext) = os.path.splitext(base) return filename def fullmodname(path): '''Return a plausible module name for the path.''' comparepath = os.path.normcase(path) longest = '' for dir in sys.path: dir = os.path.normcase(dir) if comparepath.startswith(dir) and comparepath[len(dir)] == os.sep: if len(dir) > len(longest): longest = dir len(dir) > len(longest) if longest: base = path[len(longest) + 1:] else: base = path base = base.replace(os.sep, '.') if os.altsep: base = base.replace(os.altsep, '.') (filename, ext) = os.path.splitext(base) return filename class CoverageResults: def __init__(self, counts = None, calledfuncs = None, infile = None, callers = None, outfile = None): self.counts = counts if self.counts is None: self.counts = { } self.counter = self.counts.copy() self.calledfuncs = calledfuncs if self.calledfuncs is None: self.calledfuncs = { } self.calledfuncs = self.calledfuncs.copy() self.callers = callers if self.callers is None: self.callers = { } self.callers = self.callers.copy() self.infile = infile self.outfile = outfile if self.infile: try: (counts, calledfuncs, callers) = pickle.load(open(self.infile, 'rb')) self.update(self.__class__(counts, calledfuncs, callers)) except (IOError, EOFError, ValueError): err = None print >>sys.stderr, 'Skipping counts file %r: %s' % (self.infile, err) except: None<EXCEPTION MATCH>(IOError, EOFError, ValueError) None<EXCEPTION MATCH>(IOError, EOFError, ValueError) def update(self, other): '''Merge in the data from another CoverageResults''' counts = self.counts calledfuncs = self.calledfuncs callers = self.callers other_counts = other.counts other_calledfuncs = other.calledfuncs other_callers = other.callers for key in other_counts.keys(): counts[key] = counts.get(key, 0) + other_counts[key] for key in other_calledfuncs.keys(): calledfuncs[key] = 1 for key in other_callers.keys(): callers[key] = 1 def write_results(self, show_missing = True, summary = False, coverdir = None): ''' @param coverdir ''' if self.calledfuncs: print print 'functions called:' calls = self.calledfuncs.keys() calls.sort() for filename, modulename, funcname in calls: print 'filename: %s, modulename: %s, funcname: %s' % (filename, modulename, funcname) if self.callers: print print 'calling relationships:' calls = self.callers.keys() calls.sort() lastfile = lastcfile = '' for pfile, pmod, pfunc in calls: (cfile, cmod, cfunc) = None if pfile != lastfile: print print '***', pfile, '***' lastfile = pfile lastcfile = '' if cfile != pfile and lastcfile != cfile: print ' -->', cfile lastcfile = cfile print ' %s.%s -> %s.%s' % (pmod, pfunc, cmod, cfunc) per_file = { } for filename, lineno in self.counts.keys(): lines_hit = per_file[filename] = per_file.get(filename, { }) lines_hit[lineno] = self.counts[(filename, lineno)] sums = { } for filename, count in per_file.iteritems(): if filename == '<string>': continue if filename.endswith(('.pyc', '.pyo')): filename = filename[:-1] if coverdir is None: dir = os.path.dirname(os.path.abspath(filename)) modulename = modname(filename) else: dir = coverdir if not os.path.exists(dir): os.makedirs(dir) modulename = fullmodname(filename) if show_missing: lnotab = find_executable_linenos(filename) else: lnotab = { } source = linecache.getlines(filename) coverpath = os.path.join(dir, modulename + '.cover') (n_hits, n_lines) = self.write_results_file(coverpath, source, lnotab, count) if summary and n_lines: percent = int(100 * n_hits / n_lines) sums[modulename] = (n_lines, percent, modulename, filename) continue if summary and sums: mods = sums.keys() mods.sort() print 'lines cov% module (path)' for m in mods: (n_lines, percent, modulename, filename) = sums[m] print '%5d %3d%% %s (%s)' % sums[m] if self.outfile: try: pickle.dump((self.counts, self.calledfuncs, self.callers), open(self.outfile, 'wb'), 1) except IOError: err = None print >>sys.stderr, "Can't save counts files because %s" % err except: None<EXCEPTION MATCH>IOError None<EXCEPTION MATCH>IOError def write_results_file(self, path, lines, lnotab, lines_hit): '''Return a coverage results file in path.''' try: outfile = open(path, 'w') except IOError: err = None print >>sys.stderr, 'trace: Could not open %r for writing: %s- skipping' % (path, err) return (0, 0) n_lines = 0 n_hits = 0 for i, line in enumerate(lines): lineno = i + 1 if lineno in lines_hit: outfile.write('%5d: ' % lines_hit[lineno]) n_hits += 1 n_lines += 1 elif rx_blank.match(line): outfile.write(' ') elif lineno in lnotab and PRAGMA_NOCOVER not in lines[i]: outfile.write('>>>>>> ') n_lines += 1 else: outfile.write(' ') outfile.write(lines[i].expandtabs(8)) outfile.close() return (n_hits, n_lines) def find_lines_from_code(code, strs): '''Return dict where keys are lines in the line number table.''' linenos = { } line_increments = [ ord(c) for c in code.co_lnotab[1::2] ] table_length = len(line_increments) docstring = False lineno = code.co_firstlineno for li in line_increments: lineno += li if lineno not in strs: linenos[lineno] = 1 continue [] return linenos def find_lines(code, strs): '''Return lineno dict for all code objects reachable from code.''' linenos = find_lines_from_code(code, strs) for c in code.co_consts: if isinstance(c, types.CodeType): linenos.update(find_lines(c, strs)) continue return linenos def find_strings(filename): '''Return a dict of possible docstring positions. The dict maps line numbers to strings. There is an entry for line that contains only a string or a part of a triple-quoted string. ''' d = { } prev_ttype = token.INDENT f = open(filename) for ttype, tstr, start, end, line in tokenize.generate_tokens(f.readline): if ttype == token.STRING: if prev_ttype == token.INDENT: (sline, scol) = start (eline, ecol) = end for i in range(sline, eline + 1): d[i] = 1 prev_ttype = ttype f.close() return d def find_executable_linenos(filename): '''Return dict where keys are line numbers in the line number table.''' try: prog = open(filename, 'rU').read() except IOError: err = None print >>sys.stderr, 'Not printing coverage data for %r: %s' % (filename, err) return { } code = compile(prog, filename, 'exec') strs = find_strings(filename) return find_lines(code, strs) class Trace: def __init__(self, count = 1, trace = 1, countfuncs = 0, countcallers = 0, ignoremods = (), ignoredirs = (), infile = None, outfile = None): """ @param count true iff it should count number of times each line is executed @param trace true iff it should print out each line that is being counted @param countfuncs true iff it should just output a list of (filename, modulename, funcname,) for functions that were called at least once; This overrides `count' and `trace' @param ignoremods a list of the names of modules to ignore @param ignoredirs a list of the names of directories to ignore all of the (recursive) contents of @param infile file from which to read stored counts to be added into the results @param outfile file in which to write the results """ self.infile = infile self.outfile = outfile self.ignore = Ignore(ignoremods, ignoredirs) self.counts = { } self.blabbed = { } self.pathtobasename = { } self.donothing = 0 self.trace = trace self._calledfuncs = { } self._callers = { } self._caller_cache = { } if countcallers: self.globaltrace = self.globaltrace_trackcallers elif countfuncs: self.globaltrace = self.globaltrace_countfuncs elif trace and count: self.globaltrace = self.globaltrace_lt self.localtrace = self.localtrace_trace_and_count elif trace: self.globaltrace = self.globaltrace_lt self.localtrace = self.localtrace_trace elif count: self.globaltrace = self.globaltrace_lt self.localtrace = self.localtrace_count else: self.donothing = 1 def run(self, cmd): import __main__ dict = __main__.__dict__ if not self.donothing: sys.settrace(self.globaltrace) threading.settrace(self.globaltrace) try: exec cmd in dict, dict finally: if not self.donothing: sys.settrace(None) threading.settrace(None) def runctx(self, cmd, globals = None, locals = None): if globals is None: globals = { } if locals is None: locals = { } if not self.donothing: sys.settrace(self.globaltrace) threading.settrace(self.globaltrace) try: exec cmd in globals, locals finally: if not self.donothing: sys.settrace(None) threading.settrace(None) def runfunc(self, func, *args, **kw): result = None if not self.donothing: sys.settrace(self.globaltrace) try: result = func(*args, **kw) finally: if not self.donothing: sys.settrace(None) return result def file_module_function_of(self, frame): code = frame.f_code filename = code.co_filename if filename: modulename = modname(filename) else: modulename = None funcname = code.co_name clsname = None return (filename, modulename, funcname) def globaltrace_trackcallers(self, frame, why, arg): '''Handler for call events. Adds information about who called who to the self._callers dict. ''' if why == 'call': this_func = self.file_module_function_of(frame) parent_func = self.file_module_function_of(frame.f_back) self._callers[(parent_func, this_func)] = 1 def globaltrace_countfuncs(self, frame, why, arg): '''Handler for call events. Adds (filename, modulename, funcname) to the self._calledfuncs dict. ''' if why == 'call': this_func = self.file_module_function_of(frame) self._calledfuncs[this_func] = 1 def globaltrace_lt(self, frame, why, arg): """Handler for call events. If the code block being entered is to be ignored, returns `None', else returns self.localtrace. """ if why == 'call': code = frame.f_code filename = frame.f_globals.get('__file__', None) if filename: modulename = modname(filename) if modulename is not None: ignore_it = self.ignore.names(filename, modulename) if not ignore_it: if self.trace: print ' --- modulename: %s, funcname: %s' % (modulename, code.co_name) return self.localtrace else: return None def localtrace_trace_and_count(self, frame, why, arg): if why == 'line': filename = frame.f_code.co_filename lineno = frame.f_lineno key = (filename, lineno) self.counts[key] = self.counts.get(key, 0) + 1 bname = os.path.basename(filename) print '%s(%d): %s' % (bname, lineno, linecache.getline(filename, lineno)), return self.localtrace def localtrace_trace(self, frame, why, arg): if why == 'line': filename = frame.f_code.co_filename lineno = frame.f_lineno bname = os.path.basename(filename) print '%s(%d): %s' % (bname, lineno, linecache.getline(filename, lineno)), return self.localtrace def localtrace_count(self, frame, why, arg): if why == 'line': filename = frame.f_code.co_filename lineno = frame.f_lineno key = (filename, lineno) self.counts[key] = self.counts.get(key, 0) + 1 return self.localtrace def results(self): return CoverageResults(self.counts, infile = self.infile, outfile = self.outfile, calledfuncs = self._calledfuncs, callers = self._callers) def _err_exit(msg): sys.stderr.write('%s: %s\n' % (sys.argv[0], msg)) sys.exit(1) def main(argv = None): import getopt if argv is None: argv = sys.argv try: (opts, prog_argv) = getopt.getopt(argv[1:], 'tcrRf:d:msC:lT', [ 'help', 'version', 'trace', 'count', 'report', 'no-report', 'summary', 'file=', 'missing', 'ignore-module=', 'ignore-dir=', 'coverdir=', 'listfuncs', 'trackcalls']) except getopt.error: msg = None sys.stderr.write('%s: %s\n' % (sys.argv[0], msg)) sys.stderr.write("Try `%s --help' for more information\n" % sys.argv[0]) sys.exit(1) trace = 0 count = 0 report = 0 no_report = 0 counts_file = None missing = 0 ignore_modules = [] ignore_dirs = [] coverdir = None summary = 0 listfuncs = False countcallers = False for opt, val in opts: if opt == '--help': usage(sys.stdout) sys.exit(0) if opt == '--version': sys.stdout.write('trace 2.0\n') sys.exit(0) if opt == '-T' or opt == '--trackcalls': countcallers = True continue if opt == '-l' or opt == '--listfuncs': listfuncs = True continue if opt == '-t' or opt == '--trace': trace = 1 continue if opt == '-c' or opt == '--count': count = 1 continue if opt == '-r' or opt == '--report': report = 1 continue if opt == '-R' or opt == '--no-report': no_report = 1 continue if opt == '-f' or opt == '--file': counts_file = val continue if opt == '-m' or opt == '--missing': missing = 1 continue if opt == '-C' or opt == '--coverdir': coverdir = val continue if opt == '-s' or opt == '--summary': summary = 1 continue if opt == '--ignore-module': ignore_modules.append(val) continue if opt == '--ignore-dir': for s in val.split(os.pathsep): s = os.path.expandvars(s) s = s.replace('$prefix', os.path.join(sys.prefix, 'lib', 'python' + sys.version[:3])) s = s.replace('$exec_prefix', os.path.join(sys.exec_prefix, 'lib', 'python' + sys.version[:3])) s = os.path.normpath(s) ignore_dirs.append(s) continue if not 0: raise AssertionError, 'Should never get here' if listfuncs: if count or trace: _err_exit('cannot specify both --listfuncs and (--trace or --count)') if not count and trace and report and listfuncs or countcallers: _err_exit('must specify one of --trace, --count, --report, --listfuncs, or --trackcalls') if report and no_report: _err_exit('cannot specify both --report and --no-report') if report and not counts_file: _err_exit('--report requires a --file') if no_report and len(prog_argv) == 0: _err_exit('missing name of file to run') if report: results = CoverageResults(infile = counts_file, outfile = counts_file) results.write_results(missing, summary = summary, coverdir = coverdir) else: sys.argv = prog_argv progname = prog_argv[0] sys.path[0] = os.path.split(progname)[0] t = Trace(count, trace, countfuncs = listfuncs, countcallers = countcallers, ignoremods = ignore_modules, ignoredirs = ignore_dirs, infile = counts_file, outfile = counts_file) try: t.run('execfile(%r)' % (progname,)) except IOError: err = None _err_exit('Cannot run file %r because: %s' % (sys.argv[0], err)) except SystemExit: pass results = t.results() if not no_report: results.write_results(missing, summary = summary, coverdir = coverdir) if __name__ == '__main__': main() 
(.txt)